package org.usmile.algorithms.huawei.acm;

import java.util.*;

// https://fcqian.blog.csdn.net/article/details/128794908
public class _最佳对手 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int n = sc.nextInt();
        int d = sc.nextInt();

        int[] strengths = new int[n];
        for (int i = 0; i < n; i++) {
            strengths[i] = sc.nextInt();
        }

        // 升序排列
        Arrays.sort(strengths);

        // 求出所有相邻队伍实力差值，并且只保留实力差小于等于 d 的组合
        ArrayList<Integer[]> diffs = new ArrayList<>();
        for (int i = 1; i < strengths.length; i++) {
            int diff = strengths[i] - strengths[i - 1];
            // 保留实力差小于等于 d 的组合
            if (diff <= d) diffs.add(new Integer[] {i - 1, i, diff});
        }

        if (diffs.size() == 0) {
            System.out.println(-1);
            System.exit(0);
        }

        // 经过上面的代码，我们会得到所有实力差距小于等于 d 的组合
        /*
        比如例子：
        6 30
        81 87 47 59 81 18
        排序后： 18 47 59 81 81 87
        可以得到：
        [0, 1, 29] 这个含义是：队伍 0 和队伍 1 匹配组合，实力差为 29
        [1, 2, 12]
        [2, 3, 22]
        [3, 4, 0]
        [4, 5, 6]
         */

        // 进行对上面的匹配队伍进行排列组合，求到符合条件的组合数及其对应的实例差
        // 在组合的时候，不能存在重复队伍
        ArrayList<Integer[]> res = new ArrayList<>();
        dfs(0, diffs, new LinkedList<>(), res);

        // 先按照匹配队伍对数降序排列
        // 如果匹配队伍对数相同，则按照实力差值升序排列，
        res.sort((a, b) -> Objects.equals(a[0], b[0]) ? a[1] - b [1] : b[0] - a[0]);
        System.out.println(res.get(0)[1]);
    }

    public static void dfs(int index, ArrayList<Integer[]> diffs,
                           LinkedList<Integer[]> path,
                           ArrayList<Integer[]> res) {
        for (int i = index; i < diffs.size(); i++) {
            // 说明有重复的队伍，剪枝
            // 比如 [0, 1, 29] 和 [1, 2, 12] 不能进行组合，因为存在重复队伍 1
            if (path.size() != 0 && path.getLast()[1] >= diffs.get(i)[0]) continue;

            path.add(diffs.get(i));

            dfs(i + 1, diffs, path, res);

            // 统计匹配队伍的对数，以及它们的实力差总和
            int count = path.size();
            int sumDiff = 0;
            for (Integer[] a : path) {
                sumDiff += a[2];
            }
            res.add(new Integer[] {count, sumDiff});

            path.removeLast();
        }
    }

}
